package com.example.app20_animation;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.animation.AlphaAnimation;
import android.view.animation.Animation;
import android.view.animation.AnimationSet;
import android.view.animation.AnimationUtils;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.view.animation.ScaleAnimation;
import android.view.animation.TranslateAnimation;
import android.widget.ImageView;
import android.widget.TextView;

import androidx.activity.EdgeToEdge;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.graphics.Insets;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowInsetsCompat;

public class ViewAnimationActivity extends AppCompatActivity {

    private static final String TAG = "ViewAnimationActivity";

    private ImageView iv_animation;
    private TextView tv_animation_msg;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        EdgeToEdge.enable(this);
        setContentView(R.layout.activity_view_animation);
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
            Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
            return insets;
        });

        iv_animation = findViewById(R.id.iv_animation);
        tv_animation_msg = findViewById(R.id.tv_animation_msg);
    }

    /**
     * 缩放动画，编码实现
     * ScaleAnimation
     * @param view 当前视图对象
     */
    public void startCodeScale(View view) {
        tv_animation_msg.setText("Code缩放动画：宽度从0.5到1.5，高度从0.0到1.0，缩放的圆心为顶部中心点，延迟1s开始，持续2s最终还原");

        // 创建动画对象
        ScaleAnimation animation = new ScaleAnimation(0.5f, 1.5f, 0.0f, 1.0f,
                Animation.ABSOLUTE, iv_animation.getWidth() / 2, Animation.ABSOLUTE, 0);
        // 设置动画的属性
        animation.setStartOffset(1000);
        animation.setDuration(2000);
        animation.setFillBefore(true);
        // 启动动画
        iv_animation.startAnimation(animation);
    }

    /**
     * 缩放动画，Xml实现
     * scale xml 资源文件
     * 1、定义动画文件
     * 2、加载动画文件得到动画对象
     * 3、启动动画
     * @param view 当前视图对象
     */
    public void startXmlScale(View view) {
        tv_animation_msg.setText("Xml缩放动画：宽度从0.0到1.5，高度从0.0到1.0，延迟1s开始，持续3s，圆心为左上角，最终固定");
        // 加载xml动画文件
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.scale_anim);
        // 启动动画
        iv_animation.startAnimation(animation);
    }

    /**
     * 旋转动画，编码实现
     * RotateAnimation
     * @param view 当前视图对象
     */
    public void startCodeRotate(View view) {
        tv_animation_msg.setText("Code旋转动画：以图片中心点为中心，从-90度到90度，持续5s");
        // 创建动画对象
        RotateAnimation animation = new RotateAnimation(-90, 90,
                Animation.RELATIVE_TO_SELF, 0.5f,
                Animation.RELATIVE_TO_SELF, 0.5f);
        // 设置持续事件
        animation.setDuration(5000);
        // 启动动画
        iv_animation.startAnimation(animation);
    }

    /**
     * 旋转动画，xml实现
     * rotate
     * @param view 当前视图对象
     */
    public void startXmlRotate(View view) {
        tv_animation_msg.setText("Xml旋转动画：以左顶点为中心，从90度到-90度，持续5s");
        // 加载动画文件，得到动画对象
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.rotate_anim);
        // 启动动画
        iv_animation.startAnimation(animation);
    }

    /**
     * 透明度动画，编码实现
     * AlphaAnimation
     * 完全透明：0
     * 完全不透明：1
     * @param view 当前视图对象
     */
    public void startCodeAlpha(View view) {
        tv_animation_msg.setText("Code透明度动画：从完全透明到完全不透明，持续为2s");
        AlphaAnimation animation = new AlphaAnimation(0, 1);
        animation.setDuration(2000);
        iv_animation.startAnimation(animation);
    }

    /**
     * 透明度动画，xml实现
     * alpha
     * @param view 当前视图对象
     */
    public void startXmlAlpha(View view) {
        tv_animation_msg.setText("Xml透明度动画：从完全不透明到完全透明，持续为4s");
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.alpha_anim);
        iv_animation.startAnimation(animation);
    }

    /**
     * 平移动画，编码实现
     * TranslationAnimation
     * @param view 当前视图对象
     */
    public void startCodeTranslation(View view) {
        tv_animation_msg.setText("Code平移动画：向右移动一个自己的宽度，向下移动一个自己的高度，持续为2s");
        TranslateAnimation animation = new TranslateAnimation(Animation.ABSOLUTE, 0,
                Animation.RELATIVE_TO_SELF, 1,
                Animation.ABSOLUTE, 0,
                Animation.RELATIVE_TO_SELF, 1);
        animation.setDuration(2000);
        // 启动动画
        iv_animation.startAnimation(animation);
    }

    /**
     * 平移动画，xml实现
     * translation
     * @param view 当前视图对象
     */
    public void startXmlTranslation(View view) {
        tv_animation_msg.setText("Xml平移动画：从屏幕的右边逐渐移动到原来的位置，持续为2s");
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.translate_anim);
        iv_animation.startAnimation(animation);
    }

    /**
     * 复合动画，编码实现
     * AnimationSet
     * @param view 当前视图对象
     */
    public void startCodeAnimationSet(View view) {
        tv_animation_msg.setText("Code复合动画：透明度从透明到不透明，持续2s；紧接着进行旋转360度，持续1s");
        // 创建透明动画，并设置属性
        AlphaAnimation alphaAnimation = new AlphaAnimation(1, 0);
        alphaAnimation.setDuration(2000);

        // 创建旋转动画，并设置属性
        RotateAnimation rotateAnimation = new RotateAnimation(0, 360,
                Animation.RELATIVE_TO_SELF, 0.5f,
                Animation.RELATIVE_TO_SELF, 0.5f);
        rotateAnimation.setDuration(1000);
        // 设置延迟事件
        rotateAnimation.setStartOffset(2000);

        // 创建复合动画
        AnimationSet animationSet = new AnimationSet(true);
        animationSet.addAnimation(alphaAnimation);
        animationSet.addAnimation(rotateAnimation);

        // 启动复合动画
        iv_animation.startAnimation(animationSet);
    }

    /**
     * 复合动画，xml实现
     * set
     * @param view 当前视图对象
     */
    public void startXmlAnimationSet(View view) {
        tv_animation_msg.setText("Xml复合动画：透明度从透明到不透明，持续2s；紧接着进行旋转360度，持续2s");
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.set_anim);
        iv_animation.startAnimation(animation);
    }

    /**
     * 动画监听
     * @param view 当前视图对象
     */
    public void animationListenerClick(View view) {
        tv_animation_msg.setText("测试动画监听");
        // 加载动画文件，得到动画对象
        Animation animation = AnimationUtils.loadAnimation(this, R.anim.rotate_anim);
        // 设置动画重复次数
        animation.setRepeatCount(3);
        // 设置线性变化
        animation.setInterpolator(new LinearInterpolator());
        // 设置动画监听
        animation.setAnimationListener(new Animation.AnimationListener() {
            /**
             * 动画开始监听
             * @param animation The started animation.
             */
            @Override
            public void onAnimationStart(Animation animation) {
                Log.i(TAG, "onAnimationStart: 动画开始了");
            }

            /**
             * 动画结束监听
             * @param animation The animation which reached its end.
             */
            @Override
            public void onAnimationEnd(Animation animation) {
                Log.i(TAG, "onAnimationEnd: 动画结束了");
            }

            /**
             * 动画重复监听
             * @param animation The animation which was repeated.
             */
            @Override
            public void onAnimationRepeat(Animation animation) {
                Log.i(TAG, "onAnimationRepeat: 动画重复执行了~~");
            }
        });

        // 启动动画
        iv_animation.startAnimation(animation);
    }
}